home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / lib / python2.6 / mhlib.py < prev    next >
Text File  |  2009-11-02  |  33KB  |  1,006 lines
  1. """MH interface -- purely object-oriented (well, almost)
  2.  
  3. Executive summary:
  4.  
  5. import mhlib
  6.  
  7. mh = mhlib.MH()         # use default mailbox directory and profile
  8. mh = mhlib.MH(mailbox)  # override mailbox location (default from profile)
  9. mh = mhlib.MH(mailbox, profile) # override mailbox and profile
  10.  
  11. mh.error(format, ...)   # print error message -- can be overridden
  12. s = mh.getprofile(key)  # profile entry (None if not set)
  13. path = mh.getpath()     # mailbox pathname
  14. name = mh.getcontext()  # name of current folder
  15. mh.setcontext(name)     # set name of current folder
  16.  
  17. list = mh.listfolders() # names of top-level folders
  18. list = mh.listallfolders() # names of all folders, including subfolders
  19. list = mh.listsubfolders(name) # direct subfolders of given folder
  20. list = mh.listallsubfolders(name) # all subfolders of given folder
  21.  
  22. mh.makefolder(name)     # create new folder
  23. mh.deletefolder(name)   # delete folder -- must have no subfolders
  24.  
  25. f = mh.openfolder(name) # new open folder object
  26.  
  27. f.error(format, ...)    # same as mh.error(format, ...)
  28. path = f.getfullname()  # folder's full pathname
  29. path = f.getsequencesfilename() # full pathname of folder's sequences file
  30. path = f.getmessagefilename(n)  # full pathname of message n in folder
  31.  
  32. list = f.listmessages() # list of messages in folder (as numbers)
  33. n = f.getcurrent()      # get current message
  34. f.setcurrent(n)         # set current message
  35. list = f.parsesequence(seq)     # parse msgs syntax into list of messages
  36. n = f.getlast()         # get last message (0 if no messagse)
  37. f.setlast(n)            # set last message (internal use only)
  38.  
  39. dict = f.getsequences() # dictionary of sequences in folder {name: list}
  40. f.putsequences(dict)    # write sequences back to folder
  41.  
  42. f.createmessage(n, fp)  # add message from file f as number n
  43. f.removemessages(list)  # remove messages in list from folder
  44. f.refilemessages(list, tofolder) # move messages in list to other folder
  45. f.movemessage(n, tofolder, ton)  # move one message to a given destination
  46. f.copymessage(n, tofolder, ton)  # copy one message to a given destination
  47.  
  48. m = f.openmessage(n)    # new open message object (costs a file descriptor)
  49. m is a derived class of mimetools.Message(rfc822.Message), with:
  50. s = m.getheadertext()   # text of message's headers
  51. s = m.getheadertext(pred) # text of message's headers, filtered by pred
  52. s = m.getbodytext()     # text of message's body, decoded
  53. s = m.getbodytext(0)    # text of message's body, not decoded
  54. """
  55. from warnings import warnpy3k
  56. warnpy3k("the mhlib module has been removed in Python 3.0; use the mailbox "
  57.             "module instead", stacklevel=2)
  58. del warnpy3k
  59.  
  60. # XXX To do, functionality:
  61. # - annotate messages
  62. # - send messages
  63. #
  64. # XXX To do, organization:
  65. # - move IntSet to separate file
  66. # - move most Message functionality to module mimetools
  67.  
  68.  
  69. # Customizable defaults
  70.  
  71. MH_PROFILE = '~/.mh_profile'
  72. PATH = '~/Mail'
  73. MH_SEQUENCES = '.mh_sequences'
  74. FOLDER_PROTECT = 0700
  75.  
  76.  
  77. # Imported modules
  78.  
  79. import os
  80. import sys
  81. import re
  82. import mimetools
  83. import multifile
  84. import shutil
  85. from bisect import bisect
  86.  
  87. __all__ = ["MH","Error","Folder","Message"]
  88.  
  89. # Exported constants
  90.  
  91. class Error(Exception):
  92.     pass
  93.  
  94.  
  95. class MH:
  96.     """Class representing a particular collection of folders.
  97.     Optional constructor arguments are the pathname for the directory
  98.     containing the collection, and the MH profile to use.
  99.     If either is omitted or empty a default is used; the default
  100.     directory is taken from the MH profile if it is specified there."""
  101.  
  102.     def __init__(self, path = None, profile = None):
  103.         """Constructor."""
  104.         if profile is None: profile = MH_PROFILE
  105.         self.profile = os.path.expanduser(profile)
  106.         if path is None: path = self.getprofile('Path')
  107.         if not path: path = PATH
  108.         if not os.path.isabs(path) and path[0] != '~':
  109.             path = os.path.join('~', path)
  110.         path = os.path.expanduser(path)
  111.         if not os.path.isdir(path): raise Error, 'MH() path not found'
  112.         self.path = path
  113.  
  114.     def __repr__(self):
  115.         """String representation."""
  116.         return 'MH(%r, %r)' % (self.path, self.profile)
  117.  
  118.     def error(self, msg, *args):
  119.         """Routine to print an error.  May be overridden by a derived class."""
  120.         sys.stderr.write('MH error: %s\n' % (msg % args))
  121.  
  122.     def getprofile(self, key):
  123.         """Return a profile entry, None if not found."""
  124.         return pickline(self.profile, key)
  125.  
  126.     def getpath(self):
  127.         """Return the path (the name of the collection's directory)."""
  128.         return self.path
  129.  
  130.     def getcontext(self):
  131.         """Return the name of the current folder."""
  132.         context = pickline(os.path.join(self.getpath(), 'context'),
  133.                   'Current-Folder')
  134.         if not context: context = 'inbox'
  135.         return context
  136.  
  137.     def setcontext(self, context):
  138.         """Set the name of the current folder."""
  139.         fn = os.path.join(self.getpath(), 'context')
  140.         f = open(fn, "w")
  141.         f.write("Current-Folder: %s\n" % context)
  142.         f.close()
  143.  
  144.     def listfolders(self):
  145.         """Return the names of the top-level folders."""
  146.         folders = []
  147.         path = self.getpath()
  148.         for name in os.listdir(path):
  149.             fullname = os.path.join(path, name)
  150.             if os.path.isdir(fullname):
  151.                 folders.append(name)
  152.         folders.sort()
  153.         return folders
  154.  
  155.     def listsubfolders(self, name):
  156.         """Return the names of the subfolders in a given folder
  157.         (prefixed with the given folder name)."""
  158.         fullname = os.path.join(self.path, name)
  159.         # Get the link count so we can avoid listing folders
  160.         # that have no subfolders.
  161.         nlinks = os.stat(fullname).st_nlink
  162.         if nlinks <= 2:
  163.             return []
  164.         subfolders = []
  165.         subnames = os.listdir(fullname)
  166.         for subname in subnames:
  167.             fullsubname = os.path.join(fullname, subname)
  168.             if os.path.isdir(fullsubname):
  169.                 name_subname = os.path.join(name, subname)
  170.                 subfolders.append(name_subname)
  171.                 # Stop looking for subfolders when
  172.                 # we've seen them all
  173.                 nlinks = nlinks - 1
  174.                 if nlinks <= 2:
  175.                     break
  176.         subfolders.sort()
  177.         return subfolders
  178.  
  179.     def listallfolders(self):
  180.         """Return the names of all folders and subfolders, recursively."""
  181.         return self.listallsubfolders('')
  182.  
  183.     def listallsubfolders(self, name):
  184.         """Return the names of subfolders in a given folder, recursively."""
  185.         fullname = os.path.join(self.path, name)
  186.         # Get the link count so we can avoid listing folders
  187.         # that have no subfolders.
  188.         nlinks = os.stat(fullname).st_nlink
  189.         if nlinks <= 2:
  190.             return []
  191.         subfolders = []
  192.         subnames = os.listdir(fullname)
  193.         for subname in subnames:
  194.             if subname[0] == ',' or isnumeric(subname): continue
  195.             fullsubname = os.path.join(fullname, subname)
  196.             if os.path.isdir(fullsubname):
  197.                 name_subname = os.path.join(name, subname)
  198.                 subfolders.append(name_subname)
  199.                 if not os.path.islink(fullsubname):
  200.                     subsubfolders = self.listallsubfolders(
  201.                               name_subname)
  202.                     subfolders = subfolders + subsubfolders
  203.                 # Stop looking for subfolders when
  204.                 # we've seen them all
  205.                 nlinks = nlinks - 1
  206.                 if nlinks <= 2:
  207.                     break
  208.         subfolders.sort()
  209.         return subfolders
  210.  
  211.     def openfolder(self, name):
  212.         """Return a new Folder object for the named folder."""
  213.         return Folder(self, name)
  214.  
  215.     def makefolder(self, name):
  216.         """Create a new folder (or raise os.error if it cannot be created)."""
  217.         protect = pickline(self.profile, 'Folder-Protect')
  218.         if protect and isnumeric(protect):
  219.             mode = int(protect, 8)
  220.         else:
  221.             mode = FOLDER_PROTECT
  222.         os.mkdir(os.path.join(self.getpath(), name), mode)
  223.  
  224.     def deletefolder(self, name):
  225.         """Delete a folder.  This removes files in the folder but not
  226.         subdirectories.  Raise os.error if deleting the folder itself fails."""
  227.         fullname = os.path.join(self.getpath(), name)
  228.         for subname in os.listdir(fullname):
  229.             fullsubname = os.path.join(fullname, subname)
  230.             try:
  231.                 os.unlink(fullsubname)
  232.             except os.error:
  233.                 self.error('%s not deleted, continuing...' %
  234.                           fullsubname)
  235.         os.rmdir(fullname)
  236.  
  237.  
  238. numericprog = re.compile('^[1-9][0-9]*$')
  239. def isnumeric(str):
  240.     return numericprog.match(str) is not None
  241.  
  242. class Folder:
  243.     """Class representing a particular folder."""
  244.  
  245.     def __init__(self, mh, name):
  246.         """Constructor."""
  247.         self.mh = mh
  248.         self.name = name
  249.         if not os.path.isdir(self.getfullname()):
  250.             raise Error, 'no folder %s' % name
  251.  
  252.     def __repr__(self):
  253.         """String representation."""
  254.         return 'Folder(%r, %r)' % (self.mh, self.name)
  255.  
  256.     def error(self, *args):
  257.         """Error message handler."""
  258.         self.mh.error(*args)
  259.  
  260.     def getfullname(self):
  261.         """Return the full pathname of the folder."""
  262.         return os.path.join(self.mh.path, self.name)
  263.  
  264.     def getsequencesfilename(self):
  265.         """Return the full pathname of the folder's sequences file."""
  266.         return os.path.join(self.getfullname(), MH_SEQUENCES)
  267.  
  268.     def getmessagefilename(self, n):
  269.         """Return the full pathname of a message in the folder."""
  270.         return os.path.join(self.getfullname(), str(n))
  271.  
  272.     def listsubfolders(self):
  273.         """Return list of direct subfolders."""
  274.         return self.mh.listsubfolders(self.name)
  275.  
  276.     def listallsubfolders(self):
  277.         """Return list of all subfolders."""
  278.         return self.mh.listallsubfolders(self.name)
  279.  
  280.     def listmessages(self):
  281.         """Return the list of messages currently present in the folder.
  282.         As a side effect, set self.last to the last message (or 0)."""
  283.         messages = []
  284.         match = numericprog.match
  285.         append = messages.append
  286.         for name in os.listdir(self.getfullname()):
  287.             if match(name):
  288.                 append(name)
  289.         messages = map(int, messages)
  290.         messages.sort()
  291.         if messages:
  292.             self.last = messages[-1]
  293.         else:
  294.             self.last = 0
  295.         return messages
  296.  
  297.     def getsequences(self):
  298.         """Return the set of sequences for the folder."""
  299.         sequences = {}
  300.         fullname = self.getsequencesfilename()
  301.         try:
  302.             f = open(fullname, 'r')
  303.         except IOError:
  304.             return sequences
  305.         while 1:
  306.             line = f.readline()
  307.             if not line: break
  308.             fields = line.split(':')
  309.             if len(fields) != 2:
  310.                 self.error('bad sequence in %s: %s' %
  311.                           (fullname, line.strip()))
  312.             key = fields[0].strip()
  313.             value = IntSet(fields[1].strip(), ' ').tolist()
  314.             sequences[key] = value
  315.         return sequences
  316.  
  317.     def putsequences(self, sequences):
  318.         """Write the set of sequences back to the folder."""
  319.         fullname = self.getsequencesfilename()
  320.         f = None
  321.         for key, seq in sequences.iteritems():
  322.             s = IntSet('', ' ')
  323.             s.fromlist(seq)
  324.             if not f: f = open(fullname, 'w')
  325.             f.write('%s: %s\n' % (key, s.tostring()))
  326.         if not f:
  327.             try:
  328.                 os.unlink(fullname)
  329.             except os.error:
  330.                 pass
  331.         else:
  332.             f.close()
  333.  
  334.     def getcurrent(self):
  335.         """Return the current message.  Raise Error when there is none."""
  336.         seqs = self.getsequences()
  337.         try:
  338.             return max(seqs['cur'])
  339.         except (ValueError, KeyError):
  340.             raise Error, "no cur message"
  341.  
  342.     def setcurrent(self, n):
  343.         """Set the current message."""
  344.         updateline(self.getsequencesfilename(), 'cur', str(n), 0)
  345.  
  346.     def parsesequence(self, seq):
  347.         """Parse an MH sequence specification into a message list.
  348.         Attempt to mimic mh-sequence(5) as close as possible.
  349.         Also attempt to mimic observed behavior regarding which
  350.         conditions cause which error messages."""
  351.         # XXX Still not complete (see mh-format(5)).
  352.         # Missing are:
  353.         # - 'prev', 'next' as count
  354.         # - Sequence-Negation option
  355.         all = self.listmessages()
  356.         # Observed behavior: test for empty folder is done first
  357.         if not all:
  358.             raise Error, "no messages in %s" % self.name
  359.         # Common case first: all is frequently the default
  360.         if seq == 'all':
  361.             return all
  362.         # Test for X:Y before X-Y because 'seq:-n' matches both
  363.         i = seq.find(':')
  364.         if i >= 0:
  365.             head, dir, tail = seq[:i], '', seq[i+1:]
  366.             if tail[:1] in '-+':
  367.                 dir, tail = tail[:1], tail[1:]
  368.             if not isnumeric(tail):
  369.                 raise Error, "bad message list %s" % seq
  370.             try:
  371.                 count = int(tail)
  372.             except (ValueError, OverflowError):
  373.                 # Can't use sys.maxint because of i+count below
  374.                 count = len(all)
  375.             try:
  376.                 anchor = self._parseindex(head, all)
  377.             except Error, msg:
  378.                 seqs = self.getsequences()
  379.                 if not head in seqs:
  380.                     if not msg:
  381.                         msg = "bad message list %s" % seq
  382.                     raise Error, msg, sys.exc_info()[2]
  383.                 msgs = seqs[head]
  384.                 if not msgs:
  385.                     raise Error, "sequence %s empty" % head
  386.                 if dir == '-':
  387.                     return msgs[-count:]
  388.                 else:
  389.                     return msgs[:count]
  390.             else:
  391.                 if not dir:
  392.                     if head in ('prev', 'last'):
  393.                         dir = '-'
  394.                 if dir == '-':
  395.                     i = bisect(all, anchor)
  396.                     return all[max(0, i-count):i]
  397.                 else:
  398.                     i = bisect(all, anchor-1)
  399.                     return all[i:i+count]
  400.         # Test for X-Y next
  401.         i = seq.find('-')
  402.         if i >= 0:
  403.             begin = self._parseindex(seq[:i], all)
  404.             end = self._parseindex(seq[i+1:], all)
  405.             i = bisect(all, begin-1)
  406.             j = bisect(all, end)
  407.             r = all[i:j]
  408.             if not r:
  409.                 raise Error, "bad message list %s" % seq
  410.             return r
  411.         # Neither X:Y nor X-Y; must be a number or a (pseudo-)sequence
  412.         try:
  413.             n = self._parseindex(seq, all)
  414.         except Error, msg:
  415.             seqs = self.getsequences()
  416.             if not seq in seqs:
  417.                 if not msg:
  418.                     msg = "bad message list %s" % seq
  419.                 raise Error, msg
  420.             return seqs[seq]
  421.         else:
  422.             if n not in all:
  423.                 if isnumeric(seq):
  424.                     raise Error, "message %d doesn't exist" % n
  425.                 else:
  426.                     raise Error, "no %s message" % seq
  427.             else:
  428.                 return [n]
  429.  
  430.     def _parseindex(self, seq, all):
  431.         """Internal: parse a message number (or cur, first, etc.)."""
  432.         if isnumeric(seq):
  433.             try:
  434.                 return int(seq)
  435.             except (OverflowError, ValueError):
  436.                 return sys.maxint
  437.         if seq in ('cur', '.'):
  438.             return self.getcurrent()
  439.         if seq == 'first':
  440.             return all[0]
  441.         if seq == 'last':
  442.             return all[-1]
  443.         if seq == 'next':
  444.             n = self.getcurrent()
  445.             i = bisect(all, n)
  446.             try:
  447.                 return all[i]
  448.             except IndexError:
  449.                 raise Error, "no next message"
  450.         if seq == 'prev':
  451.             n = self.getcurrent()
  452.             i = bisect(all, n-1)
  453.             if i == 0:
  454.                 raise Error, "no prev message"
  455.             try:
  456.                 return all[i-1]
  457.             except IndexError:
  458.                 raise Error, "no prev message"
  459.         raise Error, None
  460.  
  461.     def openmessage(self, n):
  462.         """Open a message -- returns a Message object."""
  463.         return Message(self, n)
  464.  
  465.     def removemessages(self, list):
  466.         """Remove one or more messages -- may raise os.error."""
  467.         errors = []
  468.         deleted = []
  469.         for n in list:
  470.             path = self.getmessagefilename(n)
  471.             commapath = self.getmessagefilename(',' + str(n))
  472.             try:
  473.                 os.unlink(commapath)
  474.             except os.error:
  475.                 pass
  476.             try:
  477.                 os.rename(path, commapath)
  478.             except os.error, msg:
  479.                 errors.append(msg)
  480.             else:
  481.                 deleted.append(n)
  482.         if deleted:
  483.             self.removefromallsequences(deleted)
  484.         if errors:
  485.             if len(errors) == 1:
  486.                 raise os.error, errors[0]
  487.             else:
  488.                 raise os.error, ('multiple errors:', errors)
  489.  
  490.     def refilemessages(self, list, tofolder, keepsequences=0):
  491.         """Refile one or more messages -- may raise os.error.
  492.         'tofolder' is an open folder object."""
  493.         errors = []
  494.         refiled = {}
  495.         for n in list:
  496.             ton = tofolder.getlast() + 1
  497.             path = self.getmessagefilename(n)
  498.             topath = tofolder.getmessagefilename(ton)
  499.             try:
  500.                 os.rename(path, topath)
  501.             except os.error:
  502.                 # Try copying
  503.                 try:
  504.                     shutil.copy2(path, topath)
  505.                     os.unlink(path)
  506.                 except (IOError, os.error), msg:
  507.                     errors.append(msg)
  508.                     try:
  509.                         os.unlink(topath)
  510.                     except os.error:
  511.                         pass
  512.                     continue
  513.             tofolder.setlast(ton)
  514.             refiled[n] = ton
  515.         if refiled:
  516.             if keepsequences:
  517.                 tofolder._copysequences(self, refiled.items())
  518.             self.removefromallsequences(refiled.keys())
  519.         if errors:
  520.             if len(errors) == 1:
  521.                 raise os.error, errors[0]
  522.             else:
  523.                 raise os.error, ('multiple errors:', errors)
  524.  
  525.     def _copysequences(self, fromfolder, refileditems):
  526.         """Helper for refilemessages() to copy sequences."""
  527.         fromsequences = fromfolder.getsequences()
  528.         tosequences = self.getsequences()
  529.         changed = 0
  530.         for name, seq in fromsequences.items():
  531.             try:
  532.                 toseq = tosequences[name]
  533.                 new = 0
  534.             except KeyError:
  535.                 toseq = []
  536.                 new = 1
  537.             for fromn, ton in refileditems:
  538.                 if fromn in seq:
  539.                     toseq.append(ton)
  540.                     changed = 1
  541.             if new and toseq:
  542.                 tosequences[name] = toseq
  543.         if changed:
  544.             self.putsequences(tosequences)
  545.  
  546.     def movemessage(self, n, tofolder, ton):
  547.         """Move one message over a specific destination message,
  548.         which may or may not already exist."""
  549.         path = self.getmessagefilename(n)
  550.         # Open it to check that it exists
  551.         f = open(path)
  552.         f.close()
  553.         del f
  554.         topath = tofolder.getmessagefilename(ton)
  555.         backuptopath = tofolder.getmessagefilename(',%d' % ton)
  556.         try:
  557.             os.rename(topath, backuptopath)
  558.         except os.error:
  559.             pass
  560.         try:
  561.             os.rename(path, topath)
  562.         except os.error:
  563.             # Try copying
  564.             ok = 0
  565.             try:
  566.                 tofolder.setlast(None)
  567.                 shutil.copy2(path, topath)
  568.                 ok = 1
  569.             finally:
  570.                 if not ok:
  571.                     try:
  572.                         os.unlink(topath)
  573.                     except os.error:
  574.                         pass
  575.             os.unlink(path)
  576.         self.removefromallsequences([n])
  577.  
  578.     def copymessage(self, n, tofolder, ton):
  579.         """Copy one message over a specific destination message,
  580.         which may or may not already exist."""
  581.         path = self.getmessagefilename(n)
  582.         # Open it to check that it exists
  583.         f = open(path)
  584.         f.close()
  585.         del f
  586.         topath = tofolder.getmessagefilename(ton)
  587.         backuptopath = tofolder.getmessagefilename(',%d' % ton)
  588.         try:
  589.             os.rename(topath, backuptopath)
  590.         except os.error:
  591.             pass
  592.         ok = 0
  593.         try:
  594.             tofolder.setlast(None)
  595.             shutil.copy2(path, topath)
  596.             ok = 1
  597.         finally:
  598.             if not ok:
  599.                 try:
  600.                     os.unlink(topath)
  601.                 except os.error:
  602.                     pass
  603.  
  604.     def createmessage(self, n, txt):
  605.         """Create a message, with text from the open file txt."""
  606.         path = self.getmessagefilename(n)
  607.         backuppath = self.getmessagefilename(',%d' % n)
  608.         try:
  609.             os.rename(path, backuppath)
  610.         except os.error:
  611.             pass
  612.         ok = 0
  613.         BUFSIZE = 16*1024
  614.         try:
  615.             f = open(path, "w")
  616.             while 1:
  617.                 buf = txt.read(BUFSIZE)
  618.                 if not buf:
  619.                     break
  620.                 f.write(buf)
  621.             f.close()
  622.             ok = 1
  623.         finally:
  624.             if not ok:
  625.                 try:
  626.                     os.unlink(path)
  627.                 except os.error:
  628.                     pass
  629.  
  630.     def removefromallsequences(self, list):
  631.         """Remove one or more messages from all sequences (including last)
  632.         -- but not from 'cur'!!!"""
  633.         if hasattr(self, 'last') and self.last in list:
  634.             del self.last
  635.         sequences = self.getsequences()
  636.         changed = 0
  637.         for name, seq in sequences.items():
  638.             if name == 'cur':
  639.                 continue
  640.             for n in list:
  641.                 if n in seq:
  642.                     seq.remove(n)
  643.                     changed = 1
  644.                     if not seq:
  645.                         del sequences[name]
  646.         if changed:
  647.             self.putsequences(sequences)
  648.  
  649.     def getlast(self):
  650.         """Return the last message number."""
  651.         if not hasattr(self, 'last'):
  652.             self.listmessages() # Set self.last
  653.         return self.last
  654.  
  655.     def setlast(self, last):
  656.         """Set the last message number."""
  657.         if last is None:
  658.             if hasattr(self, 'last'):
  659.                 del self.last
  660.         else:
  661.             self.last = last
  662.  
  663. class Message(mimetools.Message):
  664.  
  665.     def __init__(self, f, n, fp = None):
  666.         """Constructor."""
  667.         self.folder = f
  668.         self.number = n
  669.         if fp is None:
  670.             path = f.getmessagefilename(n)
  671.             fp = open(path, 'r')
  672.         mimetools.Message.__init__(self, fp)
  673.  
  674.     def __repr__(self):
  675.         """String representation."""
  676.         return 'Message(%s, %s)' % (repr(self.folder), self.number)
  677.  
  678.     def getheadertext(self, pred = None):
  679.         """Return the message's header text as a string.  If an
  680.         argument is specified, it is used as a filter predicate to
  681.         decide which headers to return (its argument is the header
  682.         name converted to lower case)."""
  683.         if pred is None:
  684.             return ''.join(self.headers)
  685.         headers = []
  686.         hit = 0
  687.         for line in self.headers:
  688.             if not line[0].isspace():
  689.                 i = line.find(':')
  690.                 if i > 0:
  691.                     hit = pred(line[:i].lower())
  692.             if hit: headers.append(line)
  693.         return ''.join(headers)
  694.  
  695.     def getbodytext(self, decode = 1):
  696.         """Return the message's body text as string.  This undoes a
  697.         Content-Transfer-Encoding, but does not interpret other MIME
  698.         features (e.g. multipart messages).  To suppress decoding,
  699.         pass 0 as an argument."""
  700.         self.fp.seek(self.startofbody)
  701.         encoding = self.getencoding()
  702.         if not decode or encoding in ('', '7bit', '8bit', 'binary'):
  703.             return self.fp.read()
  704.         try:
  705.             from cStringIO import StringIO
  706.         except ImportError:
  707.             from StringIO import StringIO
  708.         output = StringIO()
  709.         mimetools.decode(self.fp, output, encoding)
  710.         return output.getvalue()
  711.  
  712.     def getbodyparts(self):
  713.         """Only for multipart messages: return the message's body as a
  714.         list of SubMessage objects.  Each submessage object behaves
  715.         (almost) as a Message object."""
  716.         if self.getmaintype() != 'multipart':
  717.             raise Error, 'Content-Type is not multipart/*'
  718.         bdry = self.getparam('boundary')
  719.         if not bdry:
  720.             raise Error, 'multipart/* without boundary param'
  721.         self.fp.seek(self.startofbody)
  722.         mf = multifile.MultiFile(self.fp)
  723.         mf.push(bdry)
  724.         parts = []
  725.         while mf.next():
  726.             n = "%s.%r" % (self.number, 1 + len(parts))
  727.             part = SubMessage(self.folder, n, mf)
  728.             parts.append(part)
  729.         mf.pop()
  730.         return parts
  731.  
  732.     def getbody(self):
  733.         """Return body, either a string or a list of messages."""
  734.         if self.getmaintype() == 'multipart':
  735.             return self.getbodyparts()
  736.         else:
  737.             return self.getbodytext()
  738.  
  739.  
  740. class SubMessage(Message):
  741.  
  742.     def __init__(self, f, n, fp):
  743.         """Constructor."""
  744.         Message.__init__(self, f, n, fp)
  745.         if self.getmaintype() == 'multipart':
  746.             self.body = Message.getbodyparts(self)
  747.         else:
  748.             self.body = Message.getbodytext(self)
  749.         self.bodyencoded = Message.getbodytext(self, decode=0)
  750.             # XXX If this is big, should remember file pointers
  751.  
  752.     def __repr__(self):
  753.         """String representation."""
  754.         f, n, fp = self.folder, self.number, self.fp
  755.         return 'SubMessage(%s, %s, %s)' % (f, n, fp)
  756.  
  757.     def getbodytext(self, decode = 1):
  758.         if not decode:
  759.             return self.bodyencoded
  760.         if type(self.body) == type(''):
  761.             return self.body
  762.  
  763.     def getbodyparts(self):
  764.         if type(self.body) == type([]):
  765.             return self.body
  766.  
  767.     def getbody(self):
  768.         return self.body
  769.  
  770.  
  771. class IntSet:
  772.     """Class implementing sets of integers.
  773.  
  774.     This is an efficient representation for sets consisting of several
  775.     continuous ranges, e.g. 1-100,200-400,402-1000 is represented
  776.     internally as a list of three pairs: [(1,100), (200,400),
  777.     (402,1000)].  The internal representation is always kept normalized.
  778.  
  779.     The constructor has up to three arguments:
  780.     - the string used to initialize the set (default ''),
  781.     - the separator between ranges (default ',')
  782.     - the separator between begin and end of a range (default '-')
  783.     The separators must be strings (not regexprs) and should be different.
  784.  
  785.     The tostring() function yields a string that can be passed to another
  786.     IntSet constructor; __repr__() is a valid IntSet constructor itself.
  787.     """
  788.  
  789.     # XXX The default begin/end separator means that negative numbers are
  790.     #     not supported very well.
  791.     #
  792.     # XXX There are currently no operations to remove set elements.
  793.  
  794.     def __init__(self, data = None, sep = ',', rng = '-'):
  795.         self.pairs = []
  796.         self.sep = sep
  797.         self.rng = rng
  798.         if data: self.fromstring(data)
  799.  
  800.     def reset(self):
  801.         self.pairs = []
  802.  
  803.     def __cmp__(self, other):
  804.         return cmp(self.pairs, other.pairs)
  805.  
  806.     def __hash__(self):
  807.         return hash(self.pairs)
  808.  
  809.     def __repr__(self):
  810.         return 'IntSet(%r, %r, %r)' % (self.tostring(), self.sep, self.rng)
  811.  
  812.     def normalize(self):
  813.         self.pairs.sort()
  814.         i = 1
  815.         while i < len(self.pairs):
  816.             alo, ahi = self.pairs[i-1]
  817.             blo, bhi = self.pairs[i]
  818.             if ahi >= blo-1:
  819.                 self.pairs[i-1:i+1] = [(alo, max(ahi, bhi))]
  820.             else:
  821.                 i = i+1
  822.  
  823.     def tostring(self):
  824.         s = ''
  825.         for lo, hi in self.pairs:
  826.             if lo == hi: t = repr(lo)
  827.             else: t = repr(lo) + self.rng + repr(hi)
  828.             if s: s = s + (self.sep + t)
  829.             else: s = t
  830.         return s
  831.  
  832.     def tolist(self):
  833.         l = []
  834.         for lo, hi in self.pairs:
  835.             m = range(lo, hi+1)
  836.             l = l + m
  837.         return l
  838.  
  839.     def fromlist(self, list):
  840.         for i in list:
  841.             self.append(i)
  842.  
  843.     def clone(self):
  844.         new = IntSet()
  845.         new.pairs = self.pairs[:]
  846.         return new
  847.  
  848.     def min(self):
  849.         return self.pairs[0][0]
  850.  
  851.     def max(self):
  852.         return self.pairs[-1][-1]
  853.  
  854.     def contains(self, x):
  855.         for lo, hi in self.pairs:
  856.             if lo <= x <= hi: return True
  857.         return False
  858.  
  859.     def append(self, x):
  860.         for i in range(len(self.pairs)):
  861.             lo, hi = self.pairs[i]
  862.             if x < lo: # Need to insert before
  863.                 if x+1 == lo:
  864.                     self.pairs[i] = (x, hi)
  865.                 else:
  866.                     self.pairs.insert(i, (x, x))
  867.                 if i > 0 and x-1 == self.pairs[i-1][1]:
  868.                     # Merge with previous
  869.                     self.pairs[i-1:i+1] = [
  870.                             (self.pairs[i-1][0],
  871.                              self.pairs[i][1])
  872.                           ]
  873.                 return
  874.             if x <= hi: # Already in set
  875.                 return
  876.         i = len(self.pairs) - 1
  877.         if i >= 0:
  878.             lo, hi = self.pairs[i]
  879.             if x-1 == hi:
  880.                 self.pairs[i] = lo, x
  881.                 return
  882.         self.pairs.append((x, x))
  883.  
  884.     def addpair(self, xlo, xhi):
  885.         if xlo > xhi: return
  886.         self.pairs.append((xlo, xhi))
  887.         self.normalize()
  888.  
  889.     def fromstring(self, data):
  890.         new = []
  891.         for part in data.split(self.sep):
  892.             list = []
  893.             for subp in part.split(self.rng):
  894.                 s = subp.strip()
  895.                 list.append(int(s))
  896.             if len(list) == 1:
  897.                 new.append((list[0], list[0]))
  898.             elif len(list) == 2 and list[0] <= list[1]:
  899.                 new.append((list[0], list[1]))
  900.             else:
  901.                 raise ValueError, 'bad data passed to IntSet'
  902.         self.pairs = self.pairs + new
  903.         self.normalize()
  904.  
  905.  
  906. # Subroutines to read/write entries in .mh_profile and .mh_sequences
  907.  
  908. def pickline(file, key, casefold = 1):
  909.     try:
  910.         f = open(file, 'r')
  911.     except IOError:
  912.         return None
  913.     pat = re.escape(key) + ':'
  914.     prog = re.compile(pat, casefold and re.IGNORECASE)
  915.     while 1:
  916.         line = f.readline()
  917.         if not line: break
  918.         if prog.match(line):
  919.             text = line[len(key)+1:]
  920.             while 1:
  921.                 line = f.readline()
  922.                 if not line or not line[0].isspace():
  923.                     break
  924.                 text = text + line
  925.             return text.strip()
  926.     return None
  927.  
  928. def updateline(file, key, value, casefold = 1):
  929.     try:
  930.         f = open(file, 'r')
  931.         lines = f.readlines()
  932.         f.close()
  933.     except IOError:
  934.         lines = []
  935.     pat = re.escape(key) + ':(.*)\n'
  936.     prog = re.compile(pat, casefold and re.IGNORECASE)
  937.     if value is None:
  938.         newline = None
  939.     else:
  940.         newline = '%s: %s\n' % (key, value)
  941.     for i in range(len(lines)):
  942.         line = lines[i]
  943.         if prog.match(line):
  944.             if newline is None:
  945.                 del lines[i]
  946.             else:
  947.                 lines[i] = newline
  948.             break
  949.     else:
  950.         if newline is not None:
  951.             lines.append(newline)
  952.     tempfile = file + "~"
  953.     f = open(tempfile, 'w')
  954.     for line in lines:
  955.         f.write(line)
  956.     f.close()
  957.     os.rename(tempfile, file)
  958.  
  959.  
  960. # Test program
  961.  
  962. def test():
  963.     global mh, f
  964.     os.system('rm -rf $HOME/Mail/@test')
  965.     mh = MH()
  966.     def do(s): print s; print eval(s)
  967.     do('mh.listfolders()')
  968.     do('mh.listallfolders()')
  969.     testfolders = ['@test', '@test/test1', '@test/test2',
  970.                    '@test/test1/test11', '@test/test1/test12',
  971.                    '@test/test1/test11/test111']
  972.     for t in testfolders: do('mh.makefolder(%r)' % (t,))
  973.     do('mh.listsubfolders(\'@test\')')
  974.     do('mh.listallsubfolders(\'@test\')')
  975.     f = mh.openfolder('@test')
  976.     do('f.listsubfolders()')
  977.     do('f.listallsubfolders()')
  978.     do('f.getsequences()')
  979.     seqs = f.getsequences()
  980.     seqs['foo'] = IntSet('1-10 12-20', ' ').tolist()
  981.     print seqs
  982.     f.putsequences(seqs)
  983.     do('f.getsequences()')
  984.     for t in reversed(testfolders): do('mh.deletefolder(%r)' % (t,))
  985.     do('mh.getcontext()')
  986.     context = mh.getcontext()
  987.     f = mh.openfolder(context)
  988.     do('f.getcurrent()')
  989.     for seq in ('first', 'last', 'cur', '.', 'prev', 'next',
  990.                 'first:3', 'last:3', 'cur:3', 'cur:-3',
  991.                 'prev:3', 'next:3',
  992.                 '1:3', '1:-3', '100:3', '100:-3', '10000:3', '10000:-3',
  993.                 'all'):
  994.         try:
  995.             do('f.parsesequence(%r)' % (seq,))
  996.         except Error, msg:
  997.             print "Error:", msg
  998.         stuff = os.popen("pick %r 2>/dev/null" % (seq,)).read()
  999.         list = map(int, stuff.split())
  1000.         print list, "<-- pick"
  1001.     do('f.listmessages()')
  1002.  
  1003.  
  1004. if __name__ == '__main__':
  1005.     test()
  1006.